"""
驱动管理器模块
==============

该模块提供了统一的驱动管理接口，方便其他项目直接使用通信管理和设备管理功能。

通过该模块，其他项目可以轻松获取底层通信和设备管理功能，而无需深入了解内部实现细节。
所有管理器都采用单例模式，确保全局只有一份实例。

系统会自动加载默认配置文件并创建所有通信和设备实例，其他项目可以直接使用而无需额外操作。
"""

import os

from typing import Optional, Dict, Any, List, Union
from .core.communication_manager import get_communication_manager, CommunicationManager
from .core.device_manager import get_device_manager, DeviceManager
from .core.config_manager import get_config_manager, ConfigManager
from .core.communication_interface import CommunicationInterface
from .core.device_interface import DeviceInterface
from .utils.logger import get_logger


logger = get_logger(__name__)

class DriverManager:
    """
    驱动管理器 - 提供统一的驱动管理接口（单例模式）
    """

    _instance = None
    _initialized = False

    def __new__(cls, config_file: Optional[str] = None):
        """
        实现单例模式
        """
        if cls._instance is None:
            cls._instance = super(DriverManager, cls).__new__(cls)
        return cls._instance

    def __init__(self, config_file: Optional[str] = None):
        """
        初始化驱动管理器

        Args:
            config_file: 配置文件路径（可选）
        """
        # 防止重复初始化
        if DriverManager._initialized:
            return

        try:
            # 获取配置管理器实例
            self.config_manager = get_config_manager(config_file)

            # 获取通信管理器实例
            self.communication_manager = get_communication_manager(config_manager=self.config_manager)

            # 获取设备管理器实例
            self.device_manager = get_device_manager(
                config_manager=self.config_manager,
                communication_manager=self.communication_manager
            )

            DriverManager._initialized = True
        except Exception as e:
            logger.error(f"DriverManager initialization failed: {e}")
            raise

    def load_communications(self, protocols: Optional[List[str]] = None) -> None:
        """
        加载通信实例

        Args:
            protocols: 要加载的协议列表，如果为None则加载所有协议
        """
        self.communication_manager.load_communications(protocols)

    def load_devices(self, protocols: Optional[List[str]] = None) -> None:
        """
        加载设备实例

        Args:
            protocols: 要加载的协议列表，如果为None则加载所有协议
        """
        self.device_manager.load_devices(protocols)

    def get_communication(self, device_id: str) -> Optional[CommunicationInterface]:
        """
        获取通信实例

        Args:
            device_id: 设备ID

        Returns:
            通信实例，如果未找到则返回None
        """
        return self.communication_manager.get_communication(device_id)

    def get_device(self, device_id: str) -> Optional[DeviceInterface]:
        """
        获取设备实例

        Args:
            device_id: 设备ID

        Returns:
            设备实例，如果未找到则返回None
        """
        return self.device_manager.get_device(device_id)

    def get_all_communications(self) -> Dict[str, CommunicationInterface]:
        """
        获取所有通信实例

        Returns:
            包含所有通信实例的字典
        """
        return self.communication_manager.get_all_communications()

    def get_all_devices(self) -> Dict[str, DeviceInterface]:
        """
        获取所有设备实例

        Returns:
            包含所有设备实例的字典
        """
        return self.device_manager.get_all_devices()

    def connect_communication(self, device_id: str) -> bool:
        """
        连接通信

        Args:
            device_id: 设备ID

        Returns:
            是否连接成功
        """
        return self.communication_manager.connect_communication(device_id)

    def disconnect_communication(self, device_id: str) -> bool:
        """
        断开通信

        Args:
            device_id: 设备ID

        Returns:
            是否断开成功
        """
        return self.communication_manager.disconnect_communication(device_id)

    def connect_device(self, device_id: str) -> bool:
        """
        连接设备

        Args:
            device_id: 设备ID

        Returns:
            是否连接成功
        """
        device = self.get_device(device_id)
        if device:
            return device.connect_device()
        return False

    def disconnect_device(self, device_id: str) -> bool:
        """
        断开设备连接

        Args:
            device_id: 设备ID

        Returns:
            是否断开成功
        """
        device = self.get_device(device_id)
        if device:
            return device.disconnect_device()
        return False



def get_driver_manager(config_file: Optional[str] = None) -> DriverManager:
    """
    获取驱动管理器实例（单例模式）

    Args:
        config_file: 配置文件路径（可选）

    Returns:
        DriverManager: 驱动管理器实例
    """
    global _driver_manager
    if _driver_manager is None:
        _driver_manager = DriverManager(config_file=config_file)
    return _driver_manager


def load_drivers(config_file: Optional[str] = None) -> DriverManager:
    """
    加载驱动（通信和设备）

    Args:
        config_file: 配置文件路径（可选）

    Returns:
        DriverManager: 驱动管理器实例
    """
    driver_manager = get_driver_manager(config_file)
    driver_manager.load_communications()
    driver_manager.load_devices()
    return driver_manager

# 全局驱动管理器实例
_driver_manager: Optional[DriverManager] = None

# 自动初始化系统 - 在模块导入时自动加载默认配置并创建所有实例
# 如果默认配置文件路径未指定，则使用基于模块位置的默认路径
try:
    # 获取当前模块的目录
    module_dir = os.path.dirname(os.path.abspath(__file__))
    # 修复路径：config目录与driver目录在同一层级，而不是driver的子目录
    default_config_path = os.path.join(module_dir, "..", "config", "user_driverconfig.json")

    if os.path.exists(default_config_path):
        _driver_manager = load_drivers(default_config_path)
        logger.info("Drivers loaded successfully from default config file")
    else:
        # 如果默认配置文件不存在，则创建一个空的驱动管理器
        _driver_manager = DriverManager()
        logger.info("Default config file not found, created empty DriverManager")
except Exception as e:
    logger.error(f"Failed to auto-initialize drivers: {e}")
    _driver_manager = DriverManager()


def get_config_manager(config_file: Optional[str] = None) -> ConfigManager:
    """
    获取配置管理器实例（全局访问点）

    Args:
        config_file: 配置文件路径（可选）

    Returns:
        ConfigManager: 配置管理器实例
    """
    driver_manager = get_driver_manager(config_file)
    return driver_manager.config_manager


def get_communication_manager(config_file: Optional[str] = None) -> CommunicationManager:
    """
    获取通信管理器实例（全局访问点）

    Args:
        config_file: 配置文件路径（可选）

    Returns:
        CommunicationManager: 通信管理器实例
    """
    driver_manager = get_driver_manager(config_file)
    return driver_manager.communication_manager


def get_device_manager(config_file: Optional[str] = None) -> DeviceManager:
    """
    获取设备管理器实例（全局访问点）

    Args:
        config_file: 配置文件路径（可选）

    Returns:
        DeviceManager: 设备管理器实例
    """
    driver_manager = get_driver_manager(config_file)
    return driver_manager.device_manager


# 为方便使用，导出主要的类和函数
__all__ = [
    "DriverManager",
    "get_driver_manager",
    "load_drivers",
    "get_config_manager",
    "get_communication_manager",
    "get_device_manager"
]